at end of bunction bodies.
static void alan_exit()
{
- return;
}
/**************************************************************************/
#include "defs.h"
cet_cs_vec_t* cet_find_cs_by_name(const QString& name);
-void cet_register(void);
-void cet_deregister(void);
+void cet_register();
+void cet_deregister();
/* short hand transmissions */
void cet_convert_init(const QString& cs_name, const int force);
void cet_convert_strings(const cet_cs_vec_t* source, const cet_cs_vec_t* target, const char* format);
-void cet_convert_deinit(void);
+void cet_convert_deinit();
void cet_disp_character_set_names(FILE* fout);
}
static void
-compegps_rd_deinit(void)
+compegps_rd_deinit()
{
gbfclose(fin);
}
static void
-compegps_data_read(void)
+compegps_data_read()
{
char* buff;
int line = 0;
}
static void
-write_route(void)
+write_route()
{
curr_index = 0;
route_disp_all(write_route_hdr_cb, nullptr, write_waypt_cb);
}
static void
-write_track(void)
+write_track()
{
curr_index = 0;
}
static void
-write_waypoints(void)
+write_waypoints()
{
waypt_disp_all(write_waypt_cb);
}
}
static void
-compegps_wr_deinit(void)
+compegps_wr_deinit()
{
mkshort_del_handle(&sh);
gbfclose(fout);
}
static void
-compegps_data_write(void)
+compegps_data_write()
{
/* because of different file extensions we can only write one GPS data type at time */
/*****************************************************************************/
/* xcsv_file_init() - prepare xcsv_file for first use. */
/*****************************************************************************/
-void xcsv_file_init(void)
+void xcsv_file_init()
{
xcsv_file.is_internal = false;
xcsv_file.field_delimiter = QString();
/* any data conversion (the input meat) */
/*****************************************************************************/
void
-xcsv_data_read(void)
+xcsv_data_read()
{
int linecount = 0;
route_head* rte = nullptr;
/* epilogues. */
/*****************************************************************************/
void
-xcsv_data_write(void)
+xcsv_data_write()
{
/* reset the index counter */
waypt_out_count = 0;
QString csv_stringclean(const QString& string, const QString& chararray);
void
-xcsv_data_read(void);
+xcsv_data_read();
void
-xcsv_data_write(void);
+xcsv_data_write();
void
-xcsv_file_init(void);
+xcsv_file_init();
void
xcsv_prologue_add(const QString&);
xcsv_ofield_add(const QString&, const QString&, const QString&, unsigned options);
void
-xcsv_destroy_style(void);
+xcsv_destroy_style();
QString
xcsv_get_char_from_constant_table(const QString& key);
typedef void (*waypt_cb)(const Waypoint*);
const global_trait* get_traits();
-void waypt_init(void);
+void waypt_init();
//void update_common_traits(const Waypoint* wpt);
void waypt_add(Waypoint* wpt);
void waypt_del(Waypoint* wpt);
-unsigned int waypt_count(void);
+unsigned int waypt_count();
void set_waypt_count(unsigned int nc);
void waypt_disp(const Waypoint* wpt);
void waypt_status_disp(int total_ct, int myct);
void waypt_compute_bounds(bounds* bounds);
Waypoint* find_waypt_by_name(const QString& name);
void waypt_flush(queue* head);
-void waypt_flush_all(void);
+void waypt_flush_all();
void waypt_backup(signed int* count, queue** head_bak);
void waypt_restore(signed int count, queue* head_bak);
void waypt_add_url(Waypoint* wpt, const QString& link,
typedef void (*route_hdr)(const route_head*);
typedef void (*route_trl)(const route_head*);
-void route_init(void);
-unsigned int route_waypt_count(void);
-unsigned int route_count(void);
-unsigned int track_waypt_count(void);
-unsigned int track_count(void);
-route_head* route_head_alloc(void);
+void route_init();
+unsigned int route_waypt_count();
+unsigned int route_count();
+unsigned int track_waypt_count();
+unsigned int track_count();
+route_head* route_head_alloc();
void route_add_head(route_head* rte);
void route_del_head(route_head* rte);
void track_add_head(route_head* rte);
void route_reverse(const route_head* rte_hd);
void route_disp_session(const session_t* se, route_hdr rh, route_trl rt, waypt_cb wc);
void track_disp_session(const session_t* se, route_hdr rh, route_trl rt, waypt_cb wc);
-void route_flush_all_routes(void);
-void route_flush_all_tracks(void);
-void route_flush_all(void);
+void route_flush_all_routes();
+void route_flush_all_tracks();
+void route_flush_all();
void route_flush(queue* head);
void route_copy(int* dst_count, int* dst_wpt_count, queue** dst, queue* src);
void route_append(queue* src);
extern posn_status tracking_status;
typedef void (*ff_init)(const QString&);
-typedef void (*ff_deinit)(void);
-typedef void (*ff_read)(void);
-typedef void (*ff_write)(void);
-typedef void (*ff_exit)(void);
+typedef void (*ff_deinit)();
+typedef void (*ff_read)();
+typedef void (*ff_write)();
+typedef void (*ff_exit)();
typedef void (*ff_writeposn)(Waypoint*);
typedef Waypoint* (*ff_readposn)(posn_status*);
char* mkshort(short_handle, const char*);
QString mkshort(short_handle, const QString&);
-short_handle mkshort_new_handle(void);
+short_handle mkshort_new_handle();
QString mkshort_from_wpt(short_handle h, const Waypoint* wpt);
void mkshort_del_handle(short_handle* h);
void setshort_length(short_handle, int n);
ff_vecs_t* find_vec(const char*, const char**);
void assign_option(const char* vecname, arglist_t* ap, const char* val);
void disp_vec_options(const char* vecname, arglist_t* ap);
-void disp_vecs(void);
+void disp_vecs();
void disp_vec(const char* vecname);
-void init_vecs(void);
-void exit_vecs(void);
+void init_vecs();
+void exit_vecs();
void disp_formats(int version);
const char* name_option(long type);
void printposn(const double c, int is_lat);
int xvasprintf(char** strp, const char* fmt, va_list ap);
char* strupper(char* src);
char* strlower(char* src);
-signed int get_tz_offset(void);
+signed int get_tz_offset();
time_t mklocaltime(struct tm* t);
time_t mkgmtime(struct tm* t);
-gpsbabel::DateTime current_time(void);
+gpsbabel::DateTime current_time();
void dotnet_time_to_time_t(double dotnet, time_t* t, int* millisecs);
signed int month_lookup(const char* m);
const char* get_cache_icon(const Waypoint* waypointp);
xml_init(fin->name, tlog3b_xgcb_map, nullptr);
xml_read();
xml_deinit();
-
- return;
}
/*******************************************************************************
}
-void DuplicateFilter::process(void)
+void DuplicateFilter::process()
{
Waypoint* waypointp;
btree_node* newnode, * btmp, * sup_tree = nullptr;
#endif
#include "filter.h"
-typedef void (*filter_init)(void);
-typedef void (*filter_process)(void);
-typedef void (*filter_deinit)(void);
-typedef void (*filter_exit)(void);
+typedef void (*filter_init)();
+typedef void (*filter_process)();
+typedef void (*filter_deinit)();
+typedef void (*filter_exit)();
typedef struct filter_vecs {
filter_init f_init;
void disp_filters(int version);
void disp_filter(const char* vecname);
void disp_filter_vec(const char* vecname);
-void disp_filter_vecs(void);
-void init_filter_vecs(void);
-void exit_filter_vecs(void);
+void disp_filter_vecs();
+void init_filter_vecs();
+void exit_filter_vecs();
#endif // FILTERDEFS_H_INCLUDED_
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(fin);
}
static void
-data_read(void)
+data_read()
{
char* buff;
int line = 0;
} gdx_info;
const gdx_info* gdx_read(const char* fname);
-const gdx_info* gdx_get_info(void);
+const gdx_info* gdx_get_info();
const gdx_info* gdx_find_file(char** dirlist);
// This is so gross. By the time we know it's not a USB device
}
def->num_fields = numOfFields;
- }
- return;
+ }
}
static uint32_t
memapi_clearerr(gbfile* self)
{
(void)self;
- return;
}
static int
}
*len = p-data;
-
- return;
}
/* @func GPS_D311_Send **************************************************
GPS_Util_Put_Short(p,strtoul(trk->trk_ident, nullptr, 0));
p += 2;
*len = p-data;
-
- return;
}
/* @func GPS_D310_Send **************************************************
while ((*p++ = *q++));
*len = p-data;
-
- return;
}
p+=sizeof(uint32);
(*trk)->tnew = *p;
-
- return;
}
p+=sizeof(uint32);
*p = (UC) trk->tnew;
-
- return;
}
}
(*way)->dst=GPS_Util_Get_Float(p);
-
-
- return;
}
(*way)->dspl = *p++;
(*way)->dst=GPS_Util_Get_Float(p);
-
- return;
}
}
(*way)->dst=GPS_Util_Get_Float(p);
-
- return;
}
GPS_Util_Put_Float(p,way->dst);
*len = 62;
-
- return;
}
GPS_Util_Put_Float(p,way->dst);
*len = 64;
-
- return;
}
*len = 121;
-
- return;
}
(*alm)->i = GPS_Util_Get_Float(p);
p+=sizeof(float);
-
- return;
}
p = data;
GPS_A500_Encode(p,alm);
-
- return;
}
p=data;
p[42] = alm->hlth;
GPS_A500_Encode(p,alm);
-
- return;
}
p = data;
*p = alm->svid;
GPS_A500_Encode(p+1,alm);
-
- return;
}
*p = alm->svid;
GPS_A500_Encode(p+1,alm);
p[43] = alm->hlth;
-
- return;
}
p+=sizeof(float);
GPS_Util_Put_Float(p,alm->i);
-
- return;
}
GPS_Make_Packet(&packet, LINK_ID[gps_link_type].Pid_Date_Time_Data,
data,8);
-
- return;
}
t = GPS_Util_Get_Double(p);
*lon = GPS_Math_Rad_To_Deg(t);
-
-
- return;
}
GPS_Make_Packet(&packet, LINK_ID[gps_link_type].Pid_Position_Data,
data,16);
-
- return;
}
p+=sizeof(int16);
(*pvt)->wn_days = GPS_Util_Get_Int(p);
-
- return;
}
/* @func GPS_A906_Get ******************************************************
*/
}
- return;
}
p += 2;
*len = p-data;
-
- return;
}
(*clp)->avg_cadence = *p;
}
p++;
-
- return;
}
*p++ = clp->avg_cadence > 0 ? clp->avg_cadence : 0xff;
*len = p-data;
-
- return;
}
*p++ = cpt->point_type;
*len = p-data;
-
- return;
}
garmin_unit_info_t garmin_unit_info[GUSB_MAX_UNITS];
-static int32 success_stub(void)
+static int32 success_stub()
{
return 1;
}
}
static void
-gusb_atexit_teardown(void)
+gusb_atexit_teardown()
{
gusb_teardown(nullptr);
}
* Grrrr!
*/
unsigned
-gusb_reset_toggles(void)
+gusb_reset_toggles()
{
static const unsigned char oinit[12] =
{0, 0, 0, 0, GUSB_SESSION_START, 0, 0, 0, 0, 0, 0, 0};
** @return [GPS_PPvt_Data] virgin pvt
**********************************************************************/
-GPS_PPvt_Data GPS_Pvt_New(void)
+GPS_PPvt_Data GPS_Pvt_New()
{
GPS_PPvt_Data ret;
** @return [GPS_PAlmanac] virgin almanac
**********************************************************************/
-GPS_PAlmanac GPS_Almanac_New(void)
+GPS_PAlmanac GPS_Almanac_New()
{
GPS_PAlmanac ret;
** @return [GPS_PTrack] virgin track
**********************************************************************/
-GPS_PTrack GPS_Track_New(void)
+GPS_PTrack GPS_Track_New()
{
GPS_PTrack ret;
** @return [GPS_PWay] virgin waypoint
**********************************************************************/
-GPS_PWay GPS_Way_New(void)
+GPS_PWay GPS_Way_New()
{
GPS_PWay ret;
int32 i;
** @return [GPS_PLap] virgin lap
**********************************************************************/
-GPS_PLap GPS_Lap_New(void)
+GPS_PLap GPS_Lap_New()
{
GPS_PLap ret;
**
** @return [GPS_PCourse] virgin Course
**********************************************************************/
-GPS_PCourse GPS_Course_New(void)
+GPS_PCourse GPS_Course_New()
{
GPS_PCourse ret;
** @return [GPS_PCourse_Lap] virgin course lap
**********************************************************************/
-GPS_PCourse_Lap GPS_Course_Lap_New(void)
+GPS_PCourse_Lap GPS_Course_Lap_New()
{
GPS_PCourse_Lap ret;
** @return [GPS_PCourse_Point] virgin course point
**********************************************************************/
-GPS_PCourse_Point GPS_Course_Point_New(void)
+GPS_PCourse_Point GPS_Course_Point_New()
{
GPS_PCourse_Point ret;
#include "gps.h"
- GPS_PPvt_Data GPS_Pvt_New(void);
+ GPS_PPvt_Data GPS_Pvt_New();
void GPS_Pvt_Del(GPS_PPvt_Data* thys);
- GPS_PAlmanac GPS_Almanac_New(void);
+ GPS_PAlmanac GPS_Almanac_New();
void GPS_Almanac_Del(GPS_PAlmanac* thys);
- GPS_PTrack GPS_Track_New(void);
+ GPS_PTrack GPS_Track_New();
void GPS_Track_Del(GPS_PTrack* thys);
- GPS_PWay GPS_Way_New(void);
+ GPS_PWay GPS_Way_New();
void GPS_Way_Del(GPS_PWay* thys);
- GPS_PLap GPS_Lap_New(void);
+ GPS_PLap GPS_Lap_New();
void GPS_Lap_Del(GPS_PLap* thys);
- GPS_PCourse GPS_Course_New(void);
+ GPS_PCourse GPS_Course_New();
void GPS_Course_Del(GPS_PCourse* thys);
- GPS_PCourse_Lap GPS_Course_Lap_New(void);
+ GPS_PCourse_Lap GPS_Course_Lap_New();
void GPS_Course_Lap_Del(GPS_PCourse_Lap* thys);
- GPS_PCourse_Point GPS_Course_Point_New(void);
+ GPS_PCourse_Point GPS_Course_Point_New();
void GPS_Course_Point_Del(GPS_PCourse_Point* thys);
#endif
** @return [void]
************************************************************************/
-void GPS_Unknown_Protocol_Print(void)
+void GPS_Unknown_Protocol_Print()
{
int32 i;
US GPS_Protocol_Version_Change(US id, US version);
COMMON int32 GPS_Protocol_Table_Set(US id);
void GPS_Protocol_Error(US tag, US data);
- void GPS_Unknown_Protocol_Print(void);
+ void GPS_Unknown_Protocol_Print();
#endif
** @return [time_t] number of bytes read
**********************************************************************/
-time_t GPS_Time_Now(void)
+time_t GPS_Time_Now()
{
time_t secs;
#include "gps.h"
- time_t GPS_Time_Now(void);
+ time_t GPS_Time_Now();
int32 GPS_Serial_Packet_Read(gpsdevh* fd, GPS_PPacket* packet);
int32 GPS_Serial_Get_Ack(gpsdevh* fd, GPS_PPacket* tra, GPS_PPacket* rec);
}
void
-gusb_syncup(void)
+gusb_syncup()
{
static int unit_number;
static const char oinit[12] =
} gusb_llops_t;
/* Provided by the common code. */
-void gusb_syncup(void);
+void gusb_syncup();
void gusb_register_ll(struct gusb_llops*);
-void gusb_list_units(void);
+void gusb_list_units();
/* Provided by the OS layers */
// int gusb_init(const char *portname, gpsdev **dh);
#include "gps.h"
- int32 GPS_Util_Little(void);
+ int32 GPS_Util_Little();
US GPS_Util_Get_Short(const UC* s);
void GPS_Util_Put_Short(UC* s, const US v);
void GPS_Error(const char* fmt, ...);
void GPS_Serial_Error(const char* hdr, ...);
void GPS_Fatal(const char* s);
- void GPS_Enable_Error(void);
- void GPS_Enable_Warning(void);
- void GPS_Disable_Error(void);
- void GPS_Disable_Warning(void);
+ void GPS_Enable_Error();
+ void GPS_Enable_Warning();
+ void GPS_Disable_Error();
+ void GPS_Disable_Warning();
void GPS_User(const char* fmt, ...);
- void GPS_Disable_User(void);
- void GPS_Enable_User(void);
+ void GPS_Disable_User();
+ void GPS_Enable_User();
void GPS_Diagnose(int32 c);
void GPS_Diag(const char* fmt, ...);
- void GPS_Enable_Diagnose(void);
- void GPS_Disable_Diagnose(void);
+ void GPS_Enable_Diagnose();
+ void GPS_Disable_Diagnose();
#endif
** @return [int32] true if little-endian
************************************************************************/
-int32 GPS_Util_Little(void)
+int32 GPS_Util_Little()
{
static union lb {
char chars[sizeof(int32)];
** @@
****************************************************************************/
-void GPS_Enable_Error(void)
+void GPS_Enable_Error()
{
gps_error = 1;
return;
** @@
****************************************************************************/
-void GPS_Enable_Warning(void)
+void GPS_Enable_Warning()
{
gps_warning = 1;
return;
** @@
****************************************************************************/
-void GPS_Disable_Error(void)
+void GPS_Disable_Error()
{
gps_error = 0;
return;
** @@
****************************************************************************/
-void GPS_Disable_Warning(void)
+void GPS_Disable_Warning()
{
gps_warning = 0;
return;
** @@
****************************************************************************/
-void GPS_Disable_User(void)
+void GPS_Disable_User()
{
gps_user = 0;
return;
** @@
****************************************************************************/
-void GPS_Enable_User(void)
+void GPS_Enable_User()
{
gps_user = 1;
return;
** @@
****************************************************************************/
-void GPS_Enable_Diagnose(void)
+void GPS_Enable_Diagnose()
{
gps_show_bytes = 1;
return;
** @@
****************************************************************************/
-void GPS_Disable_Diagnose(void)
+void GPS_Disable_Diagnose()
{
gps_show_bytes = 0;
return;
}
}
- return;
}
static void
static
void mag_track_nop(const route_head*)
{
- return;
}
static
if (reclen >= 0) {
gbfseek(mps_file, reclen+1, SEEK_CUR);
}
- return;
}
gbfseek(mps_file, -5, SEEK_CUR);
int reclen = gbfgetint32(mps_file);
gbfseek(mps_file, reclen+1, SEEK_CUR);
- return;
}
/* might need to change this to handle version dependent icon handling */
thisWaypoint->icon_descr = gt_find_desc_from_icon_number(icon, MAPSOURCE);
-
- /* The following Now done elsewhere since it can be useful to read in and
- perhaps not add to the list */
- /* waypt_add(thisWaypoint); */
-
- return;
}
/*
}
route_add_wpt(rte_head, thisWaypoint);
-
- return;
}
/*
} /* while (trk_count--) */
- return;
}
printf("};\n");
#endif
- return ;
}
packetnum++;
dbg(1, "Line %i: %s\n", packetnum, line);
- return;
}
void
mtk_erase();
}
- return;
}
write_route_end = file_write_route_end;
}
- return;
}
static void
gbfclose(file_handle);
}
- return;
}
static void
#if FILTERS_ENABLED
#define MYNAME "nukedata"
-void NukeDataFilter::process(void)
+void NukeDataFilter::process()
{
if (*nukewpts != '0') {
waypt_flush_all();
}
file_out = gbfopen(tmpname, "wb", MYNAME);
-
- return;
}
static void
}
} while (!gbfeof(psit_file_in));
- return;
-
#ifdef DUMP_ICON_TABLE
printf("\t{ -1, NULL },\n");
printf("};\n");
}
rte_wpt_index++;
- return;
}
static void
session_t(const QString& name_p, const QString& filename_p) : name{name_p},filename{filename_p} {}
};
-void session_init(void);
-void session_exit(void);
+void session_init();
+void session_exit();
void start_session(const QString& name, const QString& filename);
-const session_t* curr_session(void);
+const session_t* curr_session();
#endif // SESSION_H_INCLUDED_
#endif
static
-void dump_fields(void)
+void dump_fields()
{
char name[12];
warning(MYNAME ": Database fields:\n");
}
static void
-my_read(void)
+my_read()
{
// option processing here instead of in my_rd_init
// lets the results of option processing be automatic.
}
static void
-my_rd_deinit(void)
+my_rd_deinit()
{
SHPClose(ihandle);
DBFClose(ihandledb);
}
static void
-my_wr_deinit(void)
+my_wr_deinit()
{
SHPClose(ohandle);
DBFClose(ohandledb);
static void
-my_write(void)
+my_write()
{
// shape files can only contain one shape type in addition
// to the null shape type.
explicit XmlStreamWriter(QFile* f);
- void writeStartDocument(void);
+ void writeStartDocument();
void writeOptionalAttribute(const QString& qualifiedName, const QString& value);
void writeOptionalTextElement(const QString& qualifiedName, const QString& text);
};
}
static void
-finalize_tracks(void)
+finalize_tracks()
{
queue* elem, *tmp;
route_head* track = nullptr;
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(fin);
rte_name = QString();
}
static void
-data_read(void)
+data_read()
{
char* buf;
sdf_section_e section = sdf_unknown;
}
static void
-wr_deinit(void)
+wr_deinit()
{
mkshort_del_handle(&short_h);
gbfclose(fout);
}
static void
-data_write(void)
+data_write()
{
gbfprintf(fout, "[HEADER]\n");
gbfprintf(fout, "FILEVERSION=1\n");
}
static void
-stmwpp_rd_deinit(void)
+stmwpp_rd_deinit()
{
gbfclose(fin);
}
static void
-stmwpp_data_read(void)
+stmwpp_data_read()
{
int line = 0;
}
static void
-stmwpp_rw_deinit(void)
+stmwpp_rw_deinit()
{
mkshort_del_handle(&short_h);
gbfclose(fout);
}
static void
-stmwpp_data_write(void)
+stmwpp_data_write()
{
setshort_length(short_h, 100);
setshort_badchars(short_h, ",\r\n");
double x = wpt->latitude;
wpt->latitude = wpt->longitude;
wpt->longitude = x;
-
- return;
}
/*******************************************************************************
* %%% global callbacks called by gpsbabel main process %%% *
*******************************************************************************/
-void SwapDataFilter::process(void) /* this procedure must be present in vecs */
+void SwapDataFilter::process() /* this procedure must be present in vecs */
{
WayptFunctor<SwapDataFilter> swapdata_cb_f(this, &SwapDataFilter::swapdata_cb);
}
}
xfree(svp);
- return;
}
void
}
}
xfree(svp);
- return;
}
/*
};
void
-xcsv_destroy_style(void)
+xcsv_destroy_style()
{
/*
}
static void
-xcsv_rd_deinit(void)
+xcsv_rd_deinit()
{
xcsv_file.file->close();
delete xcsv_file.file;
}
static void
-xcsv_wr_deinit(void)
+xcsv_wr_deinit()
{
xcsv_file.stream->flush();
xcsv_file.file->close();
}
static void
-xcsv_wr_position_deinit(void)
+xcsv_wr_position_deinit()
{
xcsv_wr_deinit();
}
void xml_ignore_tags(const char** taglist);
void xml_init(const QString& fname, xg_tag_mapping* tbl,const char* encoding);
-void xml_read(void);
+void xml_read();
void xml_readstring(const char* str);
void xml_readprefixstring(const char* str);
void xml_readunicode(const QString& str);
-void xml_deinit(void);
+void xml_deinit();
#endif // XMLGENERIC_H_INCLUDED_